package 炫彩元素类

import (
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// X结构_按钮 按钮.
type X结构_按钮 struct {
	X结构_基础元素
}

// 按钮_创建.
//
// x: 按钮x坐标.
//
// y: 按钮y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// pName: 标题.
//
// hParent: 父为窗口句柄或元素句柄.
func X创建按钮(按钮x坐标, 按钮y坐标, 宽度, 高度 int32, 标题 string, 父窗口句柄 int) *X结构_按钮 {
	p := &X结构_按钮{}
	p.X设置句柄(xc.X按钮_创建(按钮x坐标, 按钮y坐标, 宽度, 高度, 标题, 父窗口句柄))
	return p
}

// 从句柄创建对象.
func X创建按钮并按句柄(句柄 int) *X结构_按钮 {
	p := &X结构_按钮{}
	p.X设置句柄(句柄)
	return p
}

// 从name创建对象, 失败返回nil.
func X创建按钮并按名称(名称 string) *X结构_按钮 {
	handle := xc.X取对象并按名称(名称)
	if handle > 0 {
		p := &X结构_按钮{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID创建对象, 失败返回nil.
func X创建按钮并按UID(UID int32) *X结构_按钮 {
	handle := xc.X取对象并按UID(UID)
	if handle > 0 {
		p := &X结构_按钮{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID名称创建对象, 失败返回nil.
func X创建按钮并按UID名称(名称 string) *X结构_按钮 {
	handle := xc.X取对象并按UID名称(名称)
	if handle > 0 {
		p := &X结构_按钮{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 按钮_判断选中, 是否选中状态.
func (b *X结构_按钮) X是否选中() bool {
	return xc.X按钮_是否选中(b.X句柄)
}

// 按钮_置选中, 设置选中状态.
//
// bCheck: 是否选中.
func (b *X结构_按钮) X设置选中(是否选中 bool) bool {
	return xc.X按钮_设置选中(b.X句柄, 是否选中)
}

// SetState 按钮_置状态.
//
// nState: 按钮状态: xcc.Common_State3_.
func (b *X结构_按钮) X设置状态(按钮状态 xcc.X普通状态) *X结构_按钮 {
	xc.X按钮_设置状态(b.X句柄, 按钮状态)
	return b
}

// GetState 按钮_取状态.
func (b *X结构_按钮) X取状态() xcc.X普通状态 {
	return xc.X按钮_取状态(b.X句柄)
}

// GetStateEx 按钮_取状态扩展.
func (b *X结构_按钮) X取状态EX() xcc.X按钮状态 {
	return xc.X按钮_取状态EX(b.X句柄)
}

// 按钮_置类型扩展, 设置按钮类型并自动修改样式和文本对齐方式.
//
// nType: 按钮类型, Button_Type_ , element_type_ , xc_ex_error.
func (b *X结构_按钮) X设置类型EX(按钮类型 xcc.X对象扩展类型) *X结构_按钮 {
	xc.X按钮_设置类型EX(b.X句柄, 按钮类型)
	return b
}

// 按钮_置组ID.
//
// nID: 组ID.
func (b *X结构_按钮) X设置组ID(组ID int32) *X结构_按钮 {
	xc.X按钮_设置组ID(b.X句柄, 组ID)
	return b
}

// 按钮_取组ID.
func (b *X结构_按钮) X取组ID() int32 {
	return xc.X按钮_取组ID(b.X句柄)
}

// 按钮_置绑定元素.
//
// hBindEle: 将要绑定的元素.
func (b *X结构_按钮) X设置绑定元素(绑定元素 int) *X结构_按钮 {
	xc.X按钮_设置绑定元素(b.X句柄, 绑定元素)
	return b
}

// 按钮_取绑定元素, 返回: 绑定的元素句柄.
func (b *X结构_按钮) X取绑定元素() int {
	return xc.X按钮_取绑定元素(b.X句柄)
}

// 按钮_置文本对齐.
//
// nFlags: 对齐方式, TextFormatFlag_ , TextAlignFlag_ , TextTrimming_.
func (b *X结构_按钮) X设置文本对齐(对齐方式 xcc.X文本对齐) *X结构_按钮 {
	xc.X按钮_设置文本对齐(b.X句柄, 对齐方式)
	return b
}

// 按钮_取文本对齐方式, 返回: TextFormatFlag_ , TextAlignFlag_ , TextTrimming_.
func (b *X结构_按钮) X取文本对齐方式() xcc.X文本对齐 {
	return xc.X按钮_取文本对齐方式(b.X句柄)
}

// 按钮_置图标对齐.
//
// align: 对齐方式, Button_Icon_Align_.
func (b *X结构_按钮) X设置图标对齐(对齐方式 xcc.X按钮图标对齐) *X结构_按钮 {
	xc.X按钮_设置图标对齐(b.X句柄, 对齐方式)
	return b
}

// 按钮_置偏移, 设置按钮文本坐标偏移量.
//
// x: 偏移量.
//
// y: 偏移量.
func (b *X结构_按钮) X设置偏移(偏移量x, 偏移量y int32) *X结构_按钮 {
	xc.X按钮_设置偏移(b.X句柄, 偏移量x, 偏移量y)
	return b
}

// 按钮_置图标偏移, 设置按钮图标坐标偏移量.
//
// x: 偏移量.
//
// y: 偏移量.
func (b *X结构_按钮) X设置图标偏移(偏移量x, 偏移量y int32) *X结构_按钮 {
	xc.X按钮_设置图标偏移(b.X句柄, 偏移量x, 偏移量y)
	return b
}

// 按钮_置图标间隔, 设置图标与文本间隔大小.
//
// size: 间隔大小.
func (b *X结构_按钮) X设置图标间隔(间隔大小 int32) *X结构_按钮 {
	xc.X按钮_设置图标间隔(b.X句柄, 间隔大小)
	return b
}

// 按钮_置文本.
//
// pName: 文本内容.
func (b *X结构_按钮) X设置文本(文本内容 string) *X结构_按钮 {
	xc.X按钮_设置文本(b.X句柄, 文本内容)
	return b
}

// 按钮_取文本.
func (b *X结构_按钮) X取文本() string {
	return xc.X按钮_取文本(b.X句柄)
}

// 按钮_置图标.
//
// hImage: 图片句柄.
func (b *X结构_按钮) X设置图标(图片句柄 int) *X结构_按钮 {
	xc.X按钮_设置图标(b.X句柄, 图片句柄)
	return b
}

// 按钮_置禁用图标.
//
// hImage: 图片句柄.
func (b *X结构_按钮) X设置禁用图标(图片句柄 int) *X结构_按钮 {
	xc.X按钮_设置禁用图标(b.X句柄, 图片句柄)
	return b
}

// 按钮_取图标, 返回图标句柄.
//
// nType: 图标类型, 0:默认图标, 1:禁用状态图标.
func (b *X结构_按钮) X取图标(图标类型 int32) int {
	return xc.X按钮_取图标(b.X句柄, 图标类型)
}

// 按钮_添加动画帧.
//
// hImage: 图片句柄.
//
// uElapse: 图片帧延时, 单位毫秒.
func (b *X结构_按钮) X添加动画帧(图片句柄 int, 图片帧延时 uint32) *X结构_按钮 {
	xc.X按钮_添加动画帧(b.X句柄, 图片句柄, 图片帧延时)
	return b
}

// 按钮_启用动画, 开始或关闭图片动画的播放.
//
// bEnable: 开始播放动画TRUE, 关闭播放动画FALSE.
//
// bLoopPlay: 是否循环播放.
func (b *X结构_按钮) X启用动画(启用 bool, 是否循环 bool) *X结构_按钮 {
	xc.X按钮_启用动画(b.X句柄, 启用, 是否循环)
	return b
}

// 按钮_启用热键前缀. 对当前文本内容处理, 将&符号后面的一个字符加上下划线.
//
// bEnable: 是否启用.
func (b *X结构_按钮) X启用热键前缀(是否启用 bool) *X结构_按钮 {
	xc.X按钮_启用热键前缀(b.X句柄, 是否启用)
	return b
}

// ------------------------- 事件 ------------------------- //

type X事件_按钮_点击 func(pbHandled *bool) int                              // 按钮点击事件.
type X事件_按钮_点击1 func(hEle int, pbHandled *bool) int                   // 按钮点击事件.
type X事件_按钮_选中 func(bCheck bool, pbHandled *bool) int            // 按钮选中事件.
type X事件_按钮_选中1 func(hEle int, bCheck bool, pbHandled *bool) int // 按钮选中事件.

// 事件_按钮被单击.
func (b *X结构_按钮) X事件_被单击(回调函数 X事件_按钮_点击) bool {
	return xc.X元素_注册事件C(b.X句柄, xcc.X元素事件_按钮_点击, 回调函数)
}

// 事件_按钮被单击1.
func (b *X结构_按钮) X事件_被单击1(回调函数 X事件_按钮_点击1) bool {
	return xc.X元素_注册事件C1(b.X句柄, xcc.X元素事件_按钮_点击, 回调函数)
}

// 按钮选中事件.
func (b *X结构_按钮) X事件_选中(回调函数 X事件_按钮_选中) bool {
	return xc.X元素_注册事件C(b.X句柄, xcc.X元素事件_按钮_选中, 回调函数)
}

// 按钮选中事件.
func (b *X结构_按钮) X事件_选中1(回调函数 X事件_按钮_选中1) bool {
	return xc.X元素_注册事件C1(b.X句柄, xcc.X元素事件_按钮_选中, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_BnClick 添加按钮点击事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *X结构_按钮) AddEvent_BnClick(pFun X事件_按钮_点击1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X元素事件_按钮_点击, onXE_BNCLICK, pFun, allowAddingMultiple...)
}

// onXE_BNCLICK 按钮点击事件.
func onXE_BNCLICK(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_按钮_点击)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_按钮_点击1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Button_Check 添加按钮选中事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (b *X结构_按钮) AddEvent_Button_Check(pFun X事件_按钮_选中1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(b.X句柄, xcc.X元素事件_按钮_选中, onXE_BUTTON_CHECK, pFun, allowAddingMultiple...)
}

// onXE_BUTTON_CHECK 按钮选中事件.
func onXE_BUTTON_CHECK(hEle int, bCheck bool, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_按钮_选中)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_按钮_选中1)(hEle, bCheck, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
